package com.xmut.xmutbackend.controller;

import com.xmut.xmutbackend.entity.Notification;
import com.xmut.xmutbackend.entity.Result;
import com.xmut.xmutbackend.service.INotificationService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.List;


@RestController
@RequestMapping("/notifications")
public class NotificationController {

    @Autowired
    private INotificationService notificationService;
    private static final Logger logger = LoggerFactory.getLogger(NotificationController.class);

    // 获取通知列表
    @GetMapping
    public Result<List<Notification>> getNotifications() {
        // 调用 INotificationService 接口的 list 方法，获取所有通知的列表
        List<Notification> notifications = notificationService.list();
        // 使用 Result 类的 success 方法封装获取到的通知列表，返回一个表示成功的响应结果
        return Result.success(notifications);
    }

    // 根据ID获取通知详情
    @GetMapping("/{id}")
    public Result<Notification> getNotificationById(@PathVariable Long id) {
        // 调用 INotificationService 接口的 getById 方法，根据传入的 id 获取对应的通知对象
        Notification notification = notificationService.getById(id);
        // 判断获取到的通知对象是否为 null
        if (notification == null) {
            // 若为 null，说明该通知不存在，调用 Result 类的 fail 方法返回失败结果，附带错误信息
            return Result.fail("通知不存在");
        }
        // 若不为 null，说明成功获取到通知，调用 Result 类的 success 方法返回成功结果，包含通知对象
        return Result.success(notification);
    }

    //添加通知功能
    // 表明该方法处理 HTTP POST 请求，请求路径为类上 @RequestMapping 指定的 /notifications
    @PostMapping
    // 定义方法，返回封装了 Notification 对象的 Result 对象，接收从请求体传入的 Notification 对象
    public Result<Notification> addNotification(@RequestBody Notification notification) {
        try {
            // 记录接收到的通知信息到日志，方便后续调试和审计
            logger.info("接收到的通知信息：{}", notification);

            // 添加必要字段验证
            // 检查通知标题是否为空或仅包含空白字符，若不满足条件则返回失败结果
            if (notification.getTitle() == null || notification.getTitle().trim().isEmpty()) {
                return Result.fail("通知标题不能为空");
            }
            // 检查通知内容是否为空或仅包含空白字符，若不满足条件则返回失败结果
            if (notification.getContent() == null || notification.getContent().trim().isEmpty()) {
                return Result.fail("通知内容不能为空");
            }
            // 检查通知类型是否为 null 或者不在 1 - 4 的范围内，若不满足条件则返回失败结果
            if (notification.getNotificationType() == null ||
                    notification.getNotificationType() < 1 ||
                    notification.getNotificationType() > 4) {
                return Result.fail("通知类型必须为1-4的整数");
            }
            // 检查发送者 ID 是否为 null，若为 null 则返回失败结果
            if (notification.getSenderId() == null) {
                return Result.fail("发送者不能为空");
            }
            // 检查接收者类型是否为 null 或者不在 1 - 5 的范围内，若不满足条件则返回失败结果
            if (notification.getReceiverType() == null ||
                    notification.getReceiverType() < 1 ||
                    notification.getReceiverType() > 5) {
                return Result.fail("接收者类型必须为1-5的整数");
            }
            // 检查接收者 ID 是否为 null，若为 null 则返回失败结果
            if (notification.getReceiverId() == null) {
                return Result.fail("接收者ID不能为空");
            }

            // 设置创建时间和更新时间，将当前时间赋值给通知对象的创建时间和更新时间字段
            notification.setCreateTime(LocalDateTime.now());
            notification.setUpdateTime(LocalDateTime.now());

            // 调用 INotificationService 接口的 save 方法将通知对象保存到数据库，返回保存操作是否成功的布尔值
            boolean save = notificationService.save(notification);
            // 根据保存结果返回不同的响应，成功则返回包含通知对象的成功结果，失败则返回失败结果
            return save ?
                    Result.success(notification) :
                    Result.fail("新增通知失败（数据库操作失败）");
        } catch (Exception e) {
            // 捕获并记录新增通知过程中出现的异常信息
            logger.error("新增通知时出现异常", e);
            // 返回包含异常信息的失败结果
            return Result.fail("新增通知失败：" + e.getMessage());
        }
    }

    // 更新通知（替换原来的updateNotificationStatus方法）
    @PutMapping("/{id}")
    public Result<Notification> updateNotification(
            @PathVariable Long id,
            @RequestBody Notification notification) {
        try {
            logger.info("接收到的更新通知信息：{}", notification);

            // 验证通知是否存在
            Notification existingNotification = notificationService.getById(id);
            if (existingNotification == null) {
                return Result.fail("通知不存在");
            }

            // 设置要更新的字段
            if (notification.getTitle() != null) {
                existingNotification.setTitle(notification.getTitle());
            }
            if (notification.getContent() != null) {
                existingNotification.setContent(notification.getContent());
            }
            if (notification.getNotificationType() != null) {
                existingNotification.setNotificationType(notification.getNotificationType());
            }
            if (notification.getSenderId() != null) {
                existingNotification.setSenderId(notification.getSenderId());
            }
            if (notification.getReceiverType() != null) {
                existingNotification.setReceiverType(notification.getReceiverType());
            }
            if (notification.getReceiverId() != null) {
                existingNotification.setReceiverId(notification.getReceiverId());
            }

            // 自动设置更新时间
            existingNotification.setUpdateTime(LocalDateTime.now());

            boolean update = notificationService.updateById(existingNotification);
            return update ?
                    Result.success(existingNotification) :
                    Result.fail("更新通知失败");
        } catch (Exception e) {
            logger.error("更新通知时出现异常", e);
            return Result.fail("更新通知失败：" + e.getMessage());
        }
    }

    // 删除通知12
    @DeleteMapping("/{id}")
    public Result<String> deleteNotification(@PathVariable Long id) {
        boolean remove = notificationService.removeById(id);
        if (!remove) {
            return Result.fail("删除通知失败");
        }
        return Result.success("删除通知成功");
    }
}